import path from 'path';
import * as fs from 'fs';
import { parse } from 'csv-parse/sync';
import { RealSqliteDatabase } from '../lib/real-sqlite-database';

const DATA_DIR = path.join(process.cwd(), 'excel', '06-21');

// 使用数据库接口
interface Device {
  id?: number;
  name: string;
  classification_name: string;
  classification_code: string;
  specialty: string;
  sequence_number: string;
  remarks: string;
}

interface Parameter {
  parameter_name: string;
  data_type?: string;
  example_description?: string;
  measurement_class?: string;
  data_source?: string;
}

interface MeasurementUnit {
  category: string;
  unit: string;
}

// SQLite 数据库实例
const db = new RealSqliteDatabase();

// 数据库已经在构造函数中初始化，不需要额外的目录创建

function readCSVFile(filename: string, skipHeaderRows: number = 0): any[] {
  const filePath = path.join(DATA_DIR, filename);
  if (!fs.existsSync(filePath)) {
    console.warn(`文件不存在: ${filePath}`);
    return [];
  }

  let contentBuffer = fs.readFileSync(filePath);
  // 处理 BOM
  if (contentBuffer[0] === 0xEF && contentBuffer[1] === 0xBB && contentBuffer[2] === 0xBF) {
    contentBuffer = contentBuffer.subarray(3);
  }

  try {
    const records = parse(contentBuffer.toString('utf-8'), {
      columns: true,
      skip_empty_lines: true,
      from_line: skipHeaderRows + 1,  // 跳过指定数量的标题行
      delimiter: ',',  // 明确指定分隔符
      quote: '"',      // 明确指定引号
      escape: '"'      // 明确指定转义字符
    });
    return records;
  } catch (error) {
    console.error(`解析CSV文件失败: ${filename}`, error);
    return [];
  }
}

// 专门为计量单位表创建的解析函数
function readMeasurementUnitsCSV(): any[] {
  const filePath = path.join(DATA_DIR, '计量单位定义表.csv');
  if (!fs.existsSync(filePath)) {
    console.warn(`文件不存在: ${filePath}`);
    return [];
  }

  let contentBuffer = fs.readFileSync(filePath);
  // 处理 BOM
  if (contentBuffer[0] === 0xEF && contentBuffer[1] === 0xBB && contentBuffer[2] === 0xBF) {
    contentBuffer = contentBuffer.subarray(3);
  }

  try {
    // 不使用 columns: true，手动处理列名
    const records = parse(contentBuffer.toString('utf-8'), {
      skip_empty_lines: true,
      from_line: 3,  // 跳过前两行（标题行和列名行）
      delimiter: ',',
      quote: '"',
      escape: '"'
    });
    return records;
  } catch (error) {
    console.error(`解析计量单位CSV文件失败:`, error);
    return [];
  }
}

async function importDevices() {
  let deviceCount = 0;

  const deviceFiles = [
    '设备表-配管专业.csv',
    '设备表-电气专业.csv',
    '设备表-暖通专业.csv',
    '设备表-通信专业.csv',
    '设备表-仪表专业.csv'
  ];

  for (const filename of deviceFiles) {
    const specialty = filename.replace('设备表-', '').replace('.csv', '');
    const records = readCSVFile(filename);

    console.log(`处理 ${filename}: ${records.length} 条记录`);

    for (const record of records) {
      const device: Partial<Device> = {
        name: record['设备表及材料表中的实体对象名称'] || record['实体对象名称'] || '',
        classification_name: record['对应的对象分类标准中的中文名称'] || record['分类名称'] || '',
        classification_code: record['分类码'] || '',
        specialty: specialty,
        sequence_number: record['序号']?.toString() || '',
        remarks: record['备注'] || ''
      };

      if (device.name && device.name.trim() !== '') {
        // 插入到数据库
        db.insertDevice({
          name: device.name,
          classification_name: device.classification_name || '',
          classification_code: device.classification_code || '',
          specialty: device.specialty || '',
          naming_table_id: '',
          position_table_id: '',
          base_params_table_id: '',
          tech_spec_table_id: '',
          sequence_number: device.sequence_number || '',
          remarks: device.remarks || ''
        });
        deviceCount++;
      }
    }
  }

  return deviceCount;
}

async function importParameters() {
  const parameters: Parameter[] = [];

  const parameterFiles = [
    '属性表-基础参数表.csv',
    '属性表-位置信息表.csv',
    '属性表-对象命名表.csv'
  ];

  for (const filename of parameterFiles) {
    const records = readCSVFile(filename);
    console.log(`处理 ${filename}: ${records.length} 条记录`);

    let validCount = 0;
    for (const record of records) {
      // 调试：打印前几条记录的键
      if (validCount < 3) {
        console.log(`记录键: ${Object.keys(record).join(', ')}`);
        console.log(`中文名称值: "${record['中文名称']}"`);
      }

      // 跳过表头和空行
      if (!record['中文名称'] ||
          record['中文名称'].includes('表C.') ||
          record['中文名称'] === '中文名称' ||
          record['中文名称'].trim() === '' ||
          /^\d+$/.test(record['中文名称'])) { // 跳过纯数字（序号）
        continue;
      }

      const param: Parameter = {
        parameter_name: record['中文名称'],
        data_type: record['数据类型'] || '',
        example_description: record['示例或属性说明'] || record['示例'] || '',
        measurement_class: record['计量类'] || record['计量分类'] || '',
        data_source: record['数据来源'] || ''
      };

      parameters.push(param);
      validCount++;
    }
    console.log(`  -> 有效参数: ${validCount} 个`);
  }

  return parameters;
}

async function importMeasurementUnits() {
  const units: MeasurementUnit[] = [];
  // 跳过第一行标题，从第二行开始解析（第二行是列名）
  const records = readCSVFile('计量单位定义表.csv', 1);

  console.log(`处理计量单位定义表: ${records.length} 条记录`);

  for (let i = 0; i < records.length; i++) {
    const record = records[i];

    // 调试：打印前几条记录
    if (i < 3) {
      console.log(`记录 ${i} 键: ${Object.keys(record).join(', ')}`);
      console.log(`记录 ${i} 值: ${JSON.stringify(record)}`);
    }

    // 根据CSV实际结构，有8列，分为4对
    // 列1: 计量类名, 列2: 计量单位, 列3: 计量类名, 列4: 计量单位,
    // 列5: 计量类名, 列6: 计量单位, 列7: 计量类名, 列8: 单计量位
    const keys = Object.keys(record);

    // 确保有8列数据
    if (keys.length >= 8) {
      const pairs = [
        [keys[0], keys[1]], // 第1对
        [keys[2], keys[3]], // 第2对
        [keys[4], keys[5]], // 第3对
        [keys[6], keys[7]]  // 第4对
      ];

      for (const [categoryKey, unitKey] of pairs) {
        const category = record[categoryKey];
        const unit = record[unitKey];

        if (category && unit &&
            category.trim() !== '' && unit.trim() !== '' &&
            category !== '计量类名') { // 跳过列名行
          units.push({
            category: category.trim(),
            unit: unit.trim()
          });
        }
      }
    } else {
      console.warn(`记录 ${i} 列数不足: ${keys.length} 列`);
    }
  }

  console.log(`  -> 有效计量单位: ${units.length} 个`);

  // 将计量单位保存到数据库（如果有相应的表）
  // 注意：当前数据库结构中没有专门的计量单位表，这里只是收集数据
  return units;
}

async function main() {
  try {
    console.log('开始导入 excel/06-21 目录下的数据到 SQLite 数据库...');

    // 清空现有数据
    console.log('清空现有数据...');
    db.clearDatabase();

    // 导入各类数据
    const deviceCount = await importDevices();
    const parameterCount = await importParameters();
    const measurementUnits = await importMeasurementUnits();

    console.log('✅ 数据导入完成!');
    console.log(`📊 导入统计:`);
    console.log(`   - 设备: ${deviceCount} 个`);
    console.log(`   - 参数: ${parameterCount} 个`);
    console.log(`   - 计量单位: ${measurementUnits.length} 个`);
    console.log(`💾 数据已保存到 SQLite 数据库: data/delivery-management.db`);

    // 验证导入结果
    const allDevices = db.getAllDevices();
    console.log(`🔍 验证: 数据库中共有 ${allDevices.length} 个设备`);

    // 按专业统计
    const stats = db.getDashboardStats();
    console.log('📈 按专业统计:');
    stats.forEach(stat => {
      console.log(`   - ${stat.name}: ${stat.count} 个设备`);
    });

  } catch (error) {
    console.error('❌ 导入失败:', error);
    process.exit(1);
  } finally {
    // 关闭数据库连接
    db.close();
  }
}

main();
